翻訳と辞書
Words near each other
・ Fringe (season 4)
・ Fringe (season 5)
・ Fringe (trim)
・ Fringe (TV series)
・ Fringe benefits tax
・ Fringe benefits tax (Australia)
・ Fringe benefits tax (India)
・ Fringe benefits tax (New Zealand)
・ Fringe dwellers
・ Fringe gene
・ Fringe Product
・ Fringe Report
・ Fringe Review
・ Fringe Rocks
・ Fringe science
Fringe search
・ Fringe shift
・ Fringe theatre
・ Fringe theories on the location of New Albion
・ Fringe theory
・ Fringe time
・ Fringe tree frog
・ Fringe World
・ Fringe-backed fire-eye
・ Fringe-eared oryx
・ Fringe-lipped bat
・ Fringe-lipped worm-eel
・ Fringe-tailed gerbil
・ Fringe-toed lizard
・ Fringed darter


Dictionary Lists
翻訳と辞書 辞書検索 [ 開発暫定版 ]
スポンサード リンク

Fringe search : ウィキペディア英語版
Fringe search

In computer science, fringe search is a recent graph search algorithm that finds the least-cost path from a given initial node to one goal node.
In essence, fringe search is a middle ground between A
*
and the iterative deepening A
* variant (IDA
*).
If ''g''(''x'') is the cost of the search path from the first node to the current, and ''h''(''x'') is the heuristic estimate of the cost from the current node to the goal, then ''ƒ''(''x'') = ''g''(''x'') + ''h''(''x''), and ''h''
* is the actual path cost to the goal. Consider IDA
*, which does a recursive left-to-right depth-first search from the root node, stopping the recursion once the goal has been found or the nodes have reached a maximum value ''ƒ''. If no goal is found in the first threshold ''ƒ'', the threshold is then increased and the algorithm searches again. I.E. It iterates on the threshold.
There are three major inefficiencies with IDA
*. First, IDA
* will repeat states when there are multiple (sometimes non-optimal) paths to a goal node - this is often solved by keeping a cache of visited states. IDA
* thus altered is denoted as memory-enhanced IDA
* (ME-IDA
*), since it uses some storage. Furthermore, IDA
* repeats all previous operations in a search when it iterates in a new threshold, which is necessary to operate with no storage. By storing the leaf nodes of a previous iteration and using them as the starting position of the next, IDA
*'s efficiency is significantly improved (otherwise, in the last iteration it would always have to visit every node in the tree).
Fringe search implements these improvements on IDA
* by making use of a data structure that is more or less two lists to iterate over the frontier or fringe of the search tree. One list ''now'', stores the current iteration, and the other list ''later'' stores the immediate next iteration. So from the root node of the search tree, ''now'' will be the root and ''later'' will be empty. Then the algorithm takes one of two actions: If ''ƒ''(head) is greater than the current threshold, remove ''head'' from ''now'' and append it to the end of ''later''; i.e. save ''head'' for the next iteration. Otherwise, if ''ƒ''(head) is less than or equal to the threshold, expand ''head'' and discard ''head'', consider its children, adding them to the beginning of ''now''. At the end of an iteration, the threshold is increased, the ''later'' list becomes the ''now'' list, and ''later'' is emptied.
An important difference here between fringe and A
* is that the contents of the lists in fringe do not necessarily have to be sorted - a significant gain over A
*, which requires the often expensive maintenance of order in its open list. Unlike A
*, however, fringe will have to visit the same nodes repeatedly, but the cost for each such visit is constant compared to the worst-case logarithmic time of sorting the list in A
*.
==Pseudocode==

Implementing both lists in one doubly linked list, where nodes following the current node are the ''later'' portion and all else are the ''now'' list follows. Using an array of pre-allocated nodes in the list for each node in the grid, access time to nodes in the list is reduced to a constant. Similarly, a marker array allows lookup of a node in the list to be done in constant time. ''g'' is stored as a hash-table, and a last marker array is stored for constant-time lookup of whether or not a node has been visited before and if a cache entry is valid.

init(start, goal)
fringe F = s
cache C() = (0, null)
flimit = h(start)
found = false
while (found == false) AND (F not empty)
fmin = ∞
for node in F, from left to right
(g, parent) = C()
f = g + h(node)
if f > flimit
fmin = min(f, fmin)
continue
if node == goal
found = true
break
for child in children(node), from right to left
g_child = g + cost(node, child)
if C() != null
(g_cached, parent) = C()
if g_child >= g_cached
continue
if child in F
remove child from F
insert child in F past node
C() = (g_child, node)
remove node from F
flimit = fmin
if reachedgoal == true
reverse_path(goal)

Reverse pseudo-code.

reverse_path(node)
(g, parent) = C()
if parent != null
reverse_path(parent)
print node


抄文引用元・出典: フリー百科事典『 ウィキペディア(Wikipedia)
ウィキペディアで「Fringe search」の詳細全文を読む



スポンサード リンク
翻訳と辞書 : 翻訳のためのインターネットリソース

Copyright(C) kotoba.ne.jp 1997-2016. All Rights Reserved.